#include "exportstatemanager.h"
#include "customfilebrowser.h"
#include "unifiedfileinfo.h"
#include <QDebug>

// 静态注册类型到Qt元对象系统
static int _exportProgressMetaType = qRegisterMetaType<ExportStateManager::ExportProgress>("ExportStateManager::ExportProgress");

// Martin Fowler重构：移除复杂的状态模式，简化为直接状态管理

ExportStateManager::ExportStateManager(QObject* parent)
    : QObject(parent)
{
    // 初始化完成延迟定时器
    m_completionTimer = new QTimer(this);
    m_completionTimer->setSingleShot(true);
    m_completionTimer->setInterval(COMPLETION_DELAY_MS);

    connect(m_completionTimer, &QTimer::timeout, this, [this]() {
        setState(ExportState::Available);
    });

}

ExportStateManager::~ExportStateManager()
{
}

// Martin Fowler重构：新的简化接口
void ExportStateManager::setExportAvailability(bool available)
{

    if (isExporting()) {
        return;
    }

    ExportState newState = available ? ExportState::Available : ExportState::Disabled;
    setState(newState);
}

// Martin Fowler重构：移除所有不再需要的旧方法

void ExportStateManager::startExport(int totalFiles)
{

    if (!canExport()) {
        qWarning() << "[ExportStateManager] 无法开始导出，当前状态不允许:" << static_cast<int>(currentState());
        return;
    }

    // 重置进度信息
    resetProgress();
    m_progress.totalFiles = totalFiles;
    m_progress.status = "准备导出...";

    setState(ExportState::Exporting);

    emit exportStarted(totalFiles);
    emit progressUpdated(m_progress);

}

void ExportStateManager::updateProgress(int completedFiles, const QString& currentFile, const QString& status)
{
    // 方案A重构：移除状态检查，无条件更新UI（MergedExportManager统一管理状态）

    updateProgressInternal(completedFiles, currentFile, status);
    emit progressUpdated(m_progress);
}

void ExportStateManager::updateProgressFromManager(int completedFiles, int totalFiles, const QString& status)
{

    // 幂等性保护：拒绝取消状态的任何进度更新
    if (currentState() == ExportState::Cancelling) {
        return;
    }

    if (!isExporting()) {
        qWarning() << "[ExportStateManager] ❌ 在非导出状态下收到进度更新，忽略";
        qWarning() << "  🎯 当前状态:" << static_cast<int>(currentState());
        return;
    }

    // 确保总数正确设置
    if (m_progress.totalFiles != totalFiles) {
        m_progress.totalFiles = totalFiles;
    }

    updateProgressInternal(completedFiles, "", status);
    emit progressUpdated(m_progress);
}

// ====== 阶段化进度支持方法（方案1：解决进度条延迟问题） =====

void ExportStateManager::updateProgressWithPhase(int completedFiles, int totalFiles, int phase, const QString& currentFile, const QString& status)
{

    // 方案A重构：移除状态检查，无条件更新UI（MergedExportManager统一管理状态）

    // 更新进度信息
    updateProgressInternal(completedFiles, currentFile, status);

    // 设置阶段信息
    m_progress.currentPhase = phase;

    // 根据阶段设置权重
    switch (phase) {
        case 1: // 页面收集阶段
            m_progress.phaseWeight = 30;
            break;
        case 2: // PDF导出阶段
            m_progress.phaseWeight = 70;
            break;
        default:
            m_progress.phaseWeight = 100;
            break;
    }

    // 计算阶段内进度
    if (totalFiles > 0) {
        m_progress.phaseProgress = (double)completedFiles / totalFiles * 100.0;
    } else {
        m_progress.phaseProgress = 0.0;
    }

    emit progressUpdated(m_progress);

}

void ExportStateManager::setPhase(int phase, const QString& phaseDescription)
{

    if (!isExporting()) {
        qWarning() << "[ExportStateManager] ❌ 在非导出状态下设置阶段，忽略";
        return;
    }

    m_progress.currentPhase = phase;

    // 根据阶段设置权重和描述
    QString description = phaseDescription;
    switch (phase) {
        case 1: // 页面收集阶段
            m_progress.phaseWeight = 30;
            if (description.isEmpty()) {
                description = "正在收集页面...";
            }
            break;
        case 2: // PDF导出阶段
            m_progress.phaseWeight = 70;
            if (description.isEmpty()) {
                description = "正在生成PDF...";
            }
            break;
        default:
            m_progress.phaseWeight = 100;
            if (description.isEmpty()) {
                description = "处理中...";
            }
            break;
    }

    m_progress.status = description;
    emit progressUpdated(m_progress);

}

void ExportStateManager::completeExport()
{

    if (!isExporting()) {
        qWarning() << "[ExportStateManager] 在非导出状态下收到完成信号，忽略";
        return;
    }

    // 更新进度为完成状态
    m_progress.completedFiles = m_progress.totalFiles;
    m_progress.status = "导出完成";

    // 发送完成信号
    emit exportCompleted("导出完成");
    emit progressUpdated(m_progress);

    // 发送Toast提示 - 只在最关键的时候
    // QString toastMessage = QString("导出成功！共处理 %1 个文件").arg(m_progress.totalFiles);
    // emit exportCompletedToast(toastMessage);

    // 启动完成延迟定时器
    m_completionTimer->start();

}

void ExportStateManager::failExport(const QString& error)
{

    if (!isExporting()) {
        qWarning() << "[ExportStateManager] 在非导出状态下收到失败信号，忽略";
        return;
    }

    m_progress.status = "导出失败: " + error;

    emit exportFailed(error);
    emit progressUpdated(m_progress);

    // 发送Toast提示 - 只在最关键的时候
    emit exportFailedToast(error);

    // 启动完成延迟定时器
    m_completionTimer->start();

}

void ExportStateManager::cancelExport()
{

    if (!isExporting()) {
        qWarning() << "[ExportStateManager] 在非导出状态下收到取消信号，忽略";
        return;
    }

    // 立即设置为取消中状态，阻止所有后续进度信号
    setState(ExportState::Cancelling);

    m_progress.status = "导出已取消";

    // 立即发送取消信号，确保UI能即时响应
    emit exportCancelled();
    emit progressUpdated(m_progress);

    // 启动状态恢复定时器，确保所有资源完全清理
    QTimer::singleShot(1000, [this]() {

        // 确保状态重置为可用，支持幂等性操作
        setState(ExportState::Available);

        // 重置进度信息，确保下次导出从干净状态开始
        resetProgress();
    });

}

void ExportStateManager::setState(ExportState newState)
{

    if (m_state == newState) {
        return;
    }

    ExportState oldState = m_state;
    m_state = newState;

    emit stateChanged(newState);
}

void ExportStateManager::updateProgressInternal(int completedFiles, const QString& currentFile, const QString& status)
{
    m_progress.completedFiles = qMin(completedFiles, m_progress.totalFiles);
    m_progress.currentFile = currentFile;

    if (!status.isEmpty()) {
        m_progress.status = status;
    } else {
        m_progress.status = QString("导出中 %1/%2").arg(completedFiles).arg(m_progress.totalFiles);
    }
}

void ExportStateManager::resetProgress()
{
    m_progress.completedFiles = 0;
    m_progress.totalFiles = 0;
    m_progress.currentFile.clear();
    m_progress.status.clear();
}

ExportStateManager::ExportState ExportStateManager::currentState() const {
    return m_state;
}

bool ExportStateManager::canExport() const {
    return m_state == ExportState::Available;
}

bool ExportStateManager::isExporting() const {
    // 幂等性保护：取消中状态视为非导出状态
    return currentState() == ExportState::Exporting;
}


// Martin Fowler重构：移除setHasFilesWithDelay方法（不再需要）